#ifndef ___fat32_subtransaccion22_crear_estructura_inicial_directorio

#define ___fat32_subtransaccion22_crear_estructura_inicial_directorio 1

#include "f32_mto.c"

#include "f32_opAT.c"
#include "f32_opBA.c"

const char fat32st22_datos_iniciales_dir[64] = {
// 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
  46, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 16,  0,  0,  0,  0,  0,  0,  0,  0, 99, 99,  0,  0,  0,  0, 99, 99,  0,  0,  0,  0,
  46, 46, 32, 32, 32, 32, 32, 32, 32, 32, 32, 16,  0,  0,  0,  0,  0,  0,  0,  0, 99, 99,  0,  0,  0,  0, 99, 99,  0,  0,  0,  0,
};

struct fat32st22_datos {
  unsigned long clusterInicial;
  unsigned long numeroBloque;
  unsigned short posicionEntrada;
  fat32_lista_bloques_para_escribir * lbpe;
  unsigned long clusterObtenido;
  unsigned long * clusteres;
  unsigned long * sectores;
  unsigned long posSector;
};

unsigned char fat32st_crear_estructura_inicial_directorio(unsigned char, unsigned int, unsigned long, unsigned long, unsigned short, void **,
                                                                                                                       unsigned char, void *);

unsigned char fat32st_crear_estructura_inicial_directorio (unsigned char estado, unsigned int transaccion, unsigned long clusterInicialDir,
                                                           unsigned long bloqueEntrada, unsigned short posicionEntrada, void ** datos,
                                                           unsigned char estadoOp, void * datosOp) {
  struct fat32st22_datos * datosST = *datos;
  switch (estado) {
  case 0:
    datosST = malloc(sizeof(struct fat32st22_datos));
    *datos = datosST;
    datosST -> clusterInicial = clusterInicialDir;
    datosST -> numeroBloque = bloqueEntrada;
    datosST -> posicionEntrada = posicionEntrada;
    return 1;
  case 1:
    46;
    struct fat32opBA_datos_solicitud ds;
    ds.ultimoClusterActual = 0;
    ds.cantidad = 1;
    fat32_crear_operacion(transaccion, &fat32op_obtener_clusteres_adicionales, &ds, sizeof ds);
    return 2;
  case 2:
    datosST -> clusteres = datosOp;
    fat32_quitar_operacion(transaccion);
    fat32_crear_operacion(transaccion, &fat32op_obtener_cadena_sectores_desde_clusteres, &(datosST -> clusteres), 2 * sizeof(unsigned long));
    return 3;
  case 3:
    datosST -> sectores = datosOp;
    fat32_quitar_operacion(transaccion);
    datosST -> lbpe = malloc(sizeof(fat32_lista_bloques_para_escribir));
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_CREAR, datosST -> lbpe, 0, 0, 0, NULL);
    datosST -> posSector = 0;
    return 4;
  case 4:
    46;
    unsigned long b;
    unsigned short s;
    char datos[512];
    for (s = 0; s < 512; s ++) datos[s] = 0;
    b = (datosST -> sectores)[datosST -> posSector];
    s = (b & 3) * 512;
    b &= ~3L;
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, b, s, 512, datos);
    (datosST -> posSector) ++;
    if ((datosST -> sectores)[datosST -> posSector]) return 4;
    return 5;
  case 5:
    46;
    unsigned long nb;
    unsigned short pb;
    nb = *(datosST -> sectores);
    pb = (nb & 3) * 512;
    nb &= ~3L;
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, nb, pb, 64, fat32st22_datos_iniciales_dir);
    unsigned long c1, c2, c3;
    unsigned char datos[2];
    c3 = *(datosST -> clusteres);
    c1 = c3 >> 16;
    c2 = c3 & 65535UL;
    fat32_convertir_a_little_endian(datos, c1, 16);
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, nb, pb + 20, 2, datos);
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, datosST -> numeroBloque,
                                                                     (datosST -> posicionEntrada) + 20, 2, datos);
    fat32_convertir_a_little_endian(datos, c2, 16);
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, nb, pb + 26, 2, datos);
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, datosST -> numeroBloque,
                                                                     (datosST -> posicionEntrada) + 26, 2, datos);
    c3 = datosST -> clusterInicial;
    c1 = c3 >> 16;
    c2 = c3 & 65535UL;
    fat32_convertir_a_little_endian(datos, c1, 16);
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, nb, pb + 20, 2, datos);
    fat32_convertir_a_little_endian(datos, c2, 16);
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, nb, pb + 26, 2, datos);
    datos[0] = 16;
    fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_ESCRIBIR, datosST -> lbpe, datosST -> numeroBloque,
                                                                     (datosST -> posicionEntrada) + 11, 1, datos);
    return 6;
  case 6:
    free(datosST -> clusteres);
    free(datosST -> sectores);
    *datos = datosST -> lbpe;
    free(datosST);
    return 0;
  }
}

#endif